package com.et114.core.utility;

/**
 * 此类使用转义字符时请注意不能使用单引号、双引号、圆括号、中括号和大括号。 此类支持转义字符\，即\后的引号与括号不起作用，将被跳过
 */

/*
 * @guanhw
 */
public final class Sentence {
	/**
	 * 搜索时忽略大小写
	 */
	public static final int			IGNORE_CASE		= 1;
	/**
	 * 搜索时忽略圆括号,即要扫描括号中内容
	 */
	public static final int			IGNORE_PARS		= 2;
	/**
	 * 搜索时仅仅查找第一个匹配串
	 */
	public static final int			ONLY_FIRST		= 4;
	/**
	 * 搜索时仅仅在匹配串是标识符时成功
	 */
	public static final int			ONLY_PHRASE		= 8;
	/**
	 * 搜索时忽略引号,即要扫描引号中内容
	 */
	public static final int			IGNORE_QUOTE	= 16;
	/**
	 * 指示删除字符串中空白字符时将引号外的字符大写
	 */
	public static final int			UPPER_WHEN_TRIM	= 16;
	/**
	 * 指示删除字符串中空白字符时将引号外的字符小写
	 */
	public static final int			LOWER_WHEN_TRIM	= 32;

	private final static boolean	LOG				= false;

	public static void log ( Object o ) {
		if ( LOG )
			System.out.println( o );
	}

	/**
	 * 构造函数
	 * 
	 * @param str
	 *            需要进行句法分析的字符串
	 */
	public Sentence ( String str ) {
		this.str = str;
	}

	/**
	 * 构造函数
	 * @param str需要进行句法分析的字符串
	 * @param escapeChar转义字符
	 */
	public Sentence ( String str , char escapeChar ) {
		this.str = str;
		this.escapeChar = escapeChar;
	}

	/**
	 * 搜索标识符
	 * @param str需要搜索标识的原串
	 * @param start搜索的起始位置
	 * @return 返回标识符最后一个字符在原串中的位置
	 */
	public static int scanIdentifier ( String str , int start ) {
		int len = str.length();
		char ch = str.charAt( start );
		if ( !Character.isJavaIdentifierStart( ch ) )
			return -1;
		int i = start + 1;
		while ( i < len ) {
			ch = str.charAt( i );
			if ( ch == ( char ) 0 )
				break;
			if ( ch == ( char ) 1 )
				break;
			if ( !Character.isJavaIdentifierPart( ch ) )
				break;
			i++;
		}
		return i - 1;
	}

	public static boolean checkIdentifier ( String ident ) {
		if ( ident == null )
			return false;
		int len = ident.length();
		if ( len == 0 )
			return false;
		char c = ident.charAt( 0 );
		if ( !Character.isJavaIdentifierStart( c ) )
			return false;

		for ( int i = 1; i < len; i++ ) {
			c = ident.charAt( i );
			if ( c == ( char ) 0 )
				return false;
			if ( c == ( char ) 1 )
				return false;
			if ( !Character.isJavaIdentifierPart( c ) )
				return false;
		}
		return true;
	}

	/**
	 * 搜索下一个匹配的引号'或"
	 * 
	 * @param str需要搜索引号的原串
	 * @param start起始位置,即头一引号在原串中的位置
	 * @param escapeChar转义字符
	 * @return 若找到,则返回匹配的引号在原串中的位置,否则返回-1
	 */
	public static int scanQuotation ( String str , int start , char escapeChar ) {
		char quote = str.charAt( start );
		if ( quote != '\"' && quote != '\'' )
			return -1;
		int idx = start + 1 , len = str.length();
		while ( idx < len ) {
			/*
			 * idx = str.indexOf(quote, idx); if (idx < 0) break; if (
			 * str.charAt(idx - 1) != escapeChar) return idx; idx++;
			 */
			char ch = str.charAt( idx );
			if ( ch == escapeChar )
				idx += 2;
			else if ( ch == quote )
				return idx;
			else
				idx++;
		}
		return -1;
	}

	/**
	 * 搜索下一个匹配的引号'或",缺省转义字符为\
	 * 
	 * @param str
	 *            需要搜索引号的原串
	 * @param start
	 *            起始位置,即头一引号在原串中的位置
	 * @return 若找到,则返回匹配的引号在原串中的位置,否则返回-1
	 */
	public static int scanQuotation ( String str , int start ) {
		return scanQuotation( str, start, '\\' );
	}

	/**
	 * 搜索下一个匹配的圆括号，但引号内的圆括号被跳过
	 * 
	 * @param str需要搜索括号的原串
	 * @param start起始位置,即左圆括号(在原串中的位置
	 * @param escapeChar转义字符
	 * @return 若找到,则返回匹配的右圆括号在原串中的位置,否则返回-1
	 */
	public static int scanParenthesis ( String str , int start , char escapeChar ) {
		if ( str.charAt( start ) != '(' )
			return -1;

		int len = str.length();
		for ( int i = start + 1; i < len; ) {
			char ch = str.charAt( i );
			switch ( ch ) {
			case '(':
				i = scanParenthesis( str, i, escapeChar );
				if ( i < 0 )
					return -1;
				i++;
				break;
			case '\"':
			case '\'':
				i = scanQuotation( str, i, escapeChar );
				if ( i < 0 )
					return -1;
				i++;
				break;
			case ')':
				return i;
			default:
				if ( ch == escapeChar )
					i++;
				i++;
				break;
			}
		}
		return -1;
	}

	/**
	 * 搜索下一个匹配的圆括号,缺省转义字符为\，且引号内的圆括号被跳过
	 * 
	 * @param str需要搜索括号的原串
	 * @param start起始位置,即左圆括号(在原串中的位置
	 * @return 若找到,则返回匹配的右圆括号在原串中的位置,否则返回-1
	 */
	public static int scanParenthesis ( String str , int start ) {
		return scanParenthesis( str, start, '\\' );
	}

	/**
	 * 搜索下一个匹配的中括号，但引号内的中括号被跳过
	 * 
	 * @param str 需要搜索括号的原串
	 * @param start起始位置,即左中括号在原串中的位置
	 * @param escapeChar转义字符
	 * @return 若找到,则返回匹配的右中括号在原串中的位置,否则返回-1
	 */
	public static int scanBracket ( String str , int start , char escapeChar ) {
		if ( str.charAt( start ) != '[' )
			return -1;

		int len = str.length();
		for ( int i = start + 1; i < len; ) {
			char ch = str.charAt( i );
			switch ( ch ) {
			case '[':
				i = scanBracket( str, i, escapeChar );
				if ( i < 0 )
					return -1;
				i++;
				break;
			case '\"':
			case '\'':
				i = scanQuotation( str, i, escapeChar );
				if ( i < 0 )
					return -1;
				i++;
				break;
			case ']':
				return i;
			default:
				if ( ch == escapeChar )
					i++;
				i++;
				break;
			}
		}
		return -1;
	}

	/**
	 * 搜索下一个匹配的中括号,缺省转义字符为\，且引号内的中括号被跳过
	 * @param str需要搜索括号的原串
	 * @param start起始位置,即左中括号在原串中的位置
	 * @return 若找到,则返回匹配的右中括号在原串中的位置,否则返回-1
	 */
	public static int scanBracket ( String str , int start ) {
		return scanBracket( str, start, '\\' );
	}

	/**
	 * 搜索下一个匹配的花括号，但引号内的花括号被跳过
	 * @param str需要搜索括号的原串
	 * @param start起始位置,即左花括号在原串中的位置
	 * @param escapeChar转义字符
	 * @return 若找到,则返回匹配的右花括号在原串中的位置,否则返回-1
	 */
	public static int scanBrace ( String str , int start , char escapeChar ) {
		if ( str.charAt( start ) != '{' )
			return -1;

		int len = str.length();
		for ( int i = start + 1; i < len; ) {
			char ch = str.charAt( i );
			switch ( ch ) {
			case '{':
				i = scanBrace( str, i, escapeChar );
				if ( i < 0 )
					return -1;
				i++;
				break;
			case '\"':
			case '\'':
				i = scanQuotation( str, i, escapeChar );
				if ( i < 0 )
					return -1;
				i++;
				break;
			case '}':
				return i;
			default:
				if ( ch == escapeChar )
					i++;
				i++;
				break;
			}
		}
		return -1;
	}

	/**
	 * 搜索下一个匹配的花括号,缺省转义字符为\，且引号内的花括号被跳过
	 * @param str 需要搜索括号的原串
	 * @param start起始位置,即左花括号(在原串中的位置
	 * @return 若找到,则返回匹配的右花括号在原串中的位置,否则返回-1
	 */
	public static int scanBrace ( String str , int start ) {
		return scanBrace( str, start, '\\' );
	}

	/**
	 * 将原串中的空白字符删除,并根据ifcase参数将原串中的非引号内字符大写,小写或不动
	 * @param str需要删除空白字符的原串
	 * @param ifcase可以使用0, UPPER_WHEN_TRIM, LOWER_WHEN_TRIM, UPPER_WHEN_TRIM+LOWER_WHEN_TRIM
	 * @param escapeChar转义字符
	 * @return 删除空白字符后的串
	 */
	public static String trim ( String str , int ifcase , char escapeChar ) {
		int idx = 0 , len = str.length();
		int flag = 0;
		// 0 - ignore following whitespace
		// 1 - identifier char
		// 2 - whitespace
		StringBuffer dst = new StringBuffer( len );
		while ( idx < len ) {
			char ch = str.charAt( idx );
			if ( ( ch == '\"' || ch == '\'' )
					&& ( ( idx > 0 && str.charAt( idx - 1 ) != escapeChar ) || idx == 0 ) ) {
				if ( flag == 2 )
					dst.append( ' ' );
				int i = scanQuotation( str, idx, escapeChar );
				if ( i < 0 )
					throw new RuntimeException( "未找到位置" + idx + "处对应的引号" );
				i++;
				for ( int j = idx; j < i; j++ )
					dst.append( str.charAt( j ) );
				idx = i;
				continue;
			} else if ( Character.isWhitespace( ch ) ) {
				do {
					idx++;
				} while ( Character.isWhitespace( str.charAt( idx ) ) );
				if ( flag > 0 )
					flag = 2;
				continue;
			} else if ( isWordChar( ch ) ) {
				if ( flag == 2 )
					dst.append( ' ' );
				flag = 1;
			} else {
				flag = 0;
			}
			switch ( ifcase ) {
			case UPPER_WHEN_TRIM:
				dst.append( Character.toUpperCase( ch ) );
				break;
			case LOWER_WHEN_TRIM:
				dst.append( Character.toLowerCase( ch ) );
				break;
			default:
				dst.append( ch );
			}
			idx++;
		}

		return dst.toString();
	}

	/**
	 * 将原串中的空白字符删除,并根据ifcase参数将原串中的非引号内字符大写,小写或不动,缺省转义字符为\
	 * @param str需要删除空白字符的原串
	 * @param ifcase可以为0, UPPER_WHEN_TRIM, LOWER_WHEN_TRIM,UPPER_WHEN_TRIM+LOWER_WHEN_TRIM
	 * @return 删除空白字符后的串
	 */
	public static String trim ( String str , int ifcase ) {
		return trim( str, ifcase, '\\' );
	}

	/**
	 * 在原串中搜索短语，不搜索引号中内容
	 * @param str 需要搜索短语的原串
	 * @param phrase需要搜索的短语
	 * @param start 在原串中的起始位置
	 * @param flag可以为0,IGNORE_CASE,IGNORE_PARS,IGNORE_CASE+IGNORE_PARS
	 * @param escapeChar转义字符
	 * @return 若找到,则返回短语在原串中的位置,否则返回-1
	 */
	public static int phraseAt ( String str , String phrase , int start ,
			int flag , char escapeChar ) {
		int slen = str.length() , plen = phrase.length();
		boolean iswordchar = false;
		for ( int i = start; i < slen; ) {
			char ch = str.charAt( i );
			if ( ( ch == '\"' || ch == '\'' )
					&& ( ( i > 0 && str.charAt( i - 1 ) != '\\' ) || i == 0 ) ) {
				i = scanQuotation( str, i, escapeChar );
				if ( i < 0 )
					return -1;
				i++;
				iswordchar = false;
				continue;
			}
			if ( ( flag & IGNORE_PARS ) == 0 && ch == '(' ) {
				i = scanParenthesis( str, i, escapeChar );
				if ( i < 0 )
					return -1;
				i++;
				iswordchar = false;
				continue;
			}
			if ( !iswordchar ) {
				if ( phrase.regionMatches( ( flag & IGNORE_CASE ) > 0, 0, str,
						i, plen ) ) {
					if ( ( i + plen ) >= slen
							|| !isWordChar( str.charAt( i + plen ) ) )
						return i;
				}
			}
			iswordchar = isWordChar( ch );
			i++;
		}
		return -1;
	}

	/**
	 * 在原串中搜索短语,缺省转义字符为\
	 * @param str需要搜索短语的原串
	 * @param phrase需要搜索的短语
	 * @param start在原串中的起始位置
	 * @param flag可以为0,IGNORE_CASE,IGNORE_PARS及其加法组合
	 * @return 若找到,则返回短语在原串中的位置,否则返回-1
	 */
	public static int phraseAt ( String str , String phrase , int start ,
			int flag ) {
		return phraseAt( str, phrase, start, flag, '\\' );
	}

	/**
	 * 替换原串中的子串
	 * @param str需要替换的原串
	 * @param start 对原串开始替换的起始位置
	 * @param sold 需要替换的子串
	 * @param snew替换串
	 * @param flag 可为0,IGNORE_CASE,IGNORE_PARS,IGNORE_QUOTE,ONLY_FIRST,ONLY_PHRASE及其加法组合
	 * @param escapeChar转义字符
	 * @return 替换后的串
	 */
	public static String replace ( String str , int start , String sold ,
			String snew , int flag , char escapeChar ) {
		int strlen = str.length() , len = sold.length();
		StringBuffer dst = null;
		char preChar = '*'; // 指示匹配串前一个字符不是有效标识符字符
		int i = start;
		while ( i < strlen ) {
			char ch = str.charAt( i );
			if ( ( ch == '\'' || ch == '\"' )
					&& ( flag & IGNORE_QUOTE ) == 0
					&& ( i == 0 || ( i > 0 && str.charAt( i - 1 ) != escapeChar ) ) ) {
				int idx = scanQuotation( str, i, escapeChar );
				if ( idx < 0 )
					throw new RuntimeException( "未找到位置" + i + "处对应的引号" );
				idx++;
				if ( dst != null )
					for ( int j = i; j < idx; j++ )
						dst.append( str.charAt( j ) );
				i = idx;
				preChar = '*';
				continue;
			}
			if ( ( ( flag & IGNORE_PARS ) == 0 ) && ( ch == '(' ) ) {
				int idx = scanParenthesis( str, i, escapeChar );
				if ( idx < 0 )
					throw new RuntimeException( "未找到位置" + i + "处对应的圆括号" );
				idx++;
				if ( dst != null )
					for ( int j = i; j < idx; j++ )
						dst.append( str.charAt( j ) );
				i = idx;
				preChar = '*';
				continue;
			}
			boolean lb;
			lb = sold
					.regionMatches( ( flag & IGNORE_CASE ) > 0, 0, str, i, len );
			if ( lb && ( flag & ONLY_PHRASE ) > 0 ) {
				// 被匹配串的第一字符及前一字符有一个不是标识符字符时为真
				lb = !isWordChar( sold.charAt( 0 ) ) || !isWordChar( preChar );
				// 被匹配串的最后字符及后一字符有一个不是标识符字符时
				if ( ( i + len ) < strlen )
					lb = lb
							&& ( !isWordChar( sold.charAt( len - 1 ) ) || !isWordChar( str
									.charAt( i + len ) ) );
			}
			if ( lb ) {
				if ( dst == null ) {
					dst = new StringBuffer( strlen << 2 );
					for ( int j = 0; j < i; j++ )
						dst.append( str.charAt( j ) );
				}
				dst.append( snew );
				i += len;
				preChar = str.charAt( i - 1 );
				if ( ( flag & ONLY_FIRST ) > 0 ) {
					while ( i < strlen )
						dst.append( str.charAt( i++ ) );
					break;
				}
			} else {
				if ( dst != null )
					dst.append( ch );
				preChar = ch;
				i++;
			}

		} // while(i<strlen)
		return ( dst == null ) ? str : dst.toString();
	}

	/**
	 * 替换原串中的子串,缺省转义字符为\
	 * @param str 需要替换的原串
	 * @param start对原串开始替换的起始位置
	 * @param sold 需要替换的子串
	 * @param snew替换串
	 * @param flag 可为0,IGNORE_CASE,IGNORE_PARS,ONLY_FIRST,ONLY_PHRASE及其加法组合
	 * @return 替换后的串
	 */
	public static String replace ( String str , int start , String sold ,
			String snew , int flag ) {
		return replace( str, start, sold, snew, flag, '\\' );
	}

	/**
	 * 替换原串中的子串,缺省转义字符为\
	 * @param str 需要替换的原串
	 * @param sold需要替换的子串
	 * @param snew替换串
	 * @param flag可为0,IGNORE_CASE,IGNORE_PARS,ONLY_FIRST,ONLY_PHRASE及其加法组合
	 * @return 替换后的串
	 */
	public static String replace ( String str , String sold , String snew ,
			int flag ) {
		return replace( str, 0, sold, snew, flag, '\\' );
	}

	/**
	 * 搜索下一个匹配的引号'或"
	 * 
	 * @param start 起始位置,即头一引号在原串中的位置
	 * @return 下一个匹配的引号在原串中的位置
	 */
	public int scanQuotation ( int start ) {
		return scanQuotation( this.str, start, escapeChar );
	}

	/**
	 * 将原串中的空白字符删除,并根据ifcase参数将原串中的非引号内字符大写,小写或不动， 将getSentence()返回的串更改为结果串
	 * @param ifcase 可以为0, UPPER_WHEN_TRIM, LOWER_WHEN_TRIM及其加法组合
	 * @return 删除空白字符后的串
	 */
	public void trim ( int ifcase ) {
		this.str = trim( this.str, ifcase, escapeChar );
	}

	/**
	 * 在原串中搜索短语
	 * @param phrase 需要搜索的短语
	 * @param start在原串中的起始位置
	 * @param flag可以为0,IGNORE_CASE,IGNORE_PARS,IGNORE_CASE+IGNORE_PARS
	 * @return 短语在原串中的位置
	 */
	public int phraseAt ( String phrase , int start , int flag ) {
		return phraseAt( this.str, phrase, start, flag, escapeChar );
	}

	/**
	 * 替换原串中的子串，并将getSentence()返回的字符串更改为结果串
	 * @param start 对原串开始替换的起始位置
	 * @param sold  需要替换的子串
	 * @param snew 替换串
	 * @param flag 可为0,IGNORE_CASE,IGNORE_PARS,ONLY_FIRST,ONLY_PHRASE及其加法组合
	 * @return 被替换子串的个数
	 */
	public int replace ( int start , String sold , String snew , int flag ) {
		int strlen = str.length() , len = sold.length() , count = 0;
		StringBuffer dst = null;
		char preChar = '*'; // 指示匹配串前一个字符不是有效标识符字符
		int i = start;
		while ( i < strlen ) {
			char ch = str.charAt( i );
			if ( ( ch == '\"' || ch == '\'' )
					&& ( ( i > 0 && str.charAt( i - 1 ) != '\\' ) || i == 0 ) ) {
				int idx = scanQuotation( str, i, escapeChar );
				if ( idx < 0 )
					return 0;
				idx++;
				if ( dst != null )
					for ( int j = i; j < idx; j++ )
						dst.append( str.charAt( j ) );
				i = idx;
				preChar = '*';
				continue;
			}
			if ( ( ( flag & IGNORE_PARS ) == 0 ) && ( ch == '(' ) ) {
				int idx = scanParenthesis( str, i, escapeChar );
				if ( idx < 0 )
					return 0;
				idx++;
				if ( dst != null )
					for ( int j = i; j < idx; j++ )
						dst.append( str.charAt( j ) );
				i = idx;
				preChar = '*';
				continue;
			}

			boolean lb;
			lb = sold
					.regionMatches( ( flag & IGNORE_CASE ) > 0, 0, str, i, len );
			if ( lb && ( flag & ONLY_PHRASE ) > 0 ) {
				// 被匹配串的第一字符及前一字符有一个不是标识符字符时为真
				lb = !isWordChar( sold.charAt( 0 ) ) || !isWordChar( preChar );
				// 被匹配串的最后字符及后一字符有一个不是标识符字符时
				if ( ( i + len ) < strlen )
					lb = lb
							&& ( !isWordChar( sold.charAt( len - 1 ) ) || !isWordChar( str
									.charAt( i + len ) ) );
			}
			if ( lb ) {
				if ( dst == null ) {
					dst = new StringBuffer( strlen << 2 );
					for ( int j = 0; j < i; j++ )
						dst.append( str.charAt( j ) );
				}
				dst.append( snew );
				i += len;
				preChar = str.charAt( i - 1 );
				count++;
				if ( ( flag & ONLY_FIRST ) > 0 ) {
					while ( i < strlen )
						dst.append( str.charAt( i++ ) );
					break;
				}
			} else {
				if ( dst != null )
					dst.append( ch );
				i++;
			}
		}
		if ( dst != null )
			str = dst.toString();
		return count;
	}

	/**
	 * 取分析后的串
	 * 
	 * @return 分析后的串
	 */
	public String toString ( ) {
		return this.str;
	}

	/**
	 * 取分析后的串
	 * 
	 * @return 分析后的串
	 */
	public String getSentence ( ) {
		return this.str;
	}

	/**
	 * 在原串中搜索字符串(可以被包含中短语中)
	 * @param phrase需要搜索的字符串
	 * @param start在原串中的起始位置
	 * @param flag  可以为0,IGNORE_CASE,IGNORE_PARS,IGNORE_CASE+IGNORE_PARS
	 * @return 字符串在原串中的位置
	 */
	public static int indexOf ( String str , String find , int start ,
			int flag , char escapeChar ) {
		int slen = str.length() , plen = find.length();
		for ( int i = start; i < slen; ) {
			char ch = str.charAt( i );
			if ( ( ch == '\"' || ch == '\'' )
					&& ( ( i > 0 && str.charAt( i - 1 ) != '\\' ) || i == 0 ) ) {
				i = scanQuotation( str, i, escapeChar );
				if ( i < 0 )
					return -1;
				i++;
				continue;
			}
			if ( ( flag & IGNORE_PARS ) == 0 && ch == '(' ) {
				i = scanParenthesis( str, i, escapeChar );
				if ( i < 0 )
					return -1;
				i++;
				continue;
			}
			if ( find.regionMatches( ( flag & IGNORE_CASE ) > 0, 0, str, i,
					plen ) ) {
				return i;
			}
			i++;
		}
		return -1;
	}

	public int indexOf ( String find , int start , int flag ) {
		return indexOf( this.str, find, start, flag, escapeChar );
	}

	public static int indexOf ( String str , String find , int start , int flag ) {
		return indexOf( str, find, start, flag, '\\' );
	}

	public static boolean isWordChar ( char ch ) {
		return Character.isJavaIdentifierStart( ch )
				|| Character.isJavaIdentifierPart( ch );
	}

	private String	str;
	private char	escapeChar	= '\\';

	public static void main ( String [ ] args ) {

		//boolean r = Character.isJavaIdentifierPart( ( char ) 0 );
		//r = Character.isJavaIdentifierPart( ( char ) 1 );
		
		String ts = "< div id='dd'> divspan</ Div >" ;
		String ts1 = replace( ts, 0, "div", "span", IGNORE_CASE );
		System.out.println( ts1 ) ; 
		
		String s = "aa select * from aa where @aa.aaa=1";
		String s1 = replace( s, 0, "@aa", "bbbbb", ONLY_PHRASE + ONLY_FIRST );
		System.out.println( s1 );
		s1 = replace( s, 0, "cc", "bbbbb", ONLY_PHRASE );
		System.out.println( s == s1 ? "equals" : "not equals" );

		s = "this is an example.";
		System.out.println( indexOf( s, "is", 0, 0 ) );
		System.out.println( phraseAt( s, "is", 0, 0 ) );

		s = "(sdfsfs\\)f(dsfsdf))";
		System.out.println( s + " -- first ( : " + scanParenthesis( s, 0 ) );

		s = "this < iS \\\" is < \\\"  \tan  'sdf is sdf'";
		System.out.println( trim( s, 0 ) );
		System.out.println( replace( s, 0, "<", "&lt;", ONLY_PHRASE
				+ IGNORE_CASE + IGNORE_QUOTE ) );
		System.out.println( replace( s, 0, "is", "***", ONLY_PHRASE
				+ IGNORE_CASE + IGNORE_QUOTE ) );
		System.out.println( new java.sql.Timestamp( new java.util.Date()
				.getTime() ) );
		// for ( int i = 0; i < 100000; i ++ )
		replace( s, 0, "is", "***", ONLY_PHRASE + IGNORE_CASE + IGNORE_QUOTE );
		System.out.println( new java.sql.Timestamp( new java.util.Date()
				.getTime() ) );

		s = "ab cd";
		System.out.println( s + "===" + scanIdentifier( s, 0 ) );

		s = "'sfsd''sdfsd'sdfsdf";
		System.out.println( scanQuotation( s, 0, '\'' ) );

		s = "1";
		System.out.println( s );
		System.out.println( replace( s, 0, "\\u", "@#x", ONLY_PHRASE
				+ IGNORE_CASE + IGNORE_QUOTE ) );

	}
}
